TDAArbolBinario

## Class BinaryTreeTests

- java.lang.Object
- - TDAArbolBinario.BinaryTreeTests

-     public class BinaryTreeTests
      extends java.lang.Object

  Tester desarrollado con JUnit 4 para la estructura BinaryTree.
  Version:
    1.0 Agosto 2017
  Author:
    Gonzalo Ezequiel Arró - Departamento de Ciencias e Ingeniería de la Computación - Universidad Nacional del Sur - gonzalo.arro@hotmail.com

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `(package private) BinaryTree<java.lang.Object>` | `binaryTree`
    `(package private) BinaryTree<java.lang.Object>` | `leftTree`
    `(package private) java.lang.Object` | `o1`
    `(package private) java.lang.Object` | `o2`
    `(package private) BinaryTree<java.lang.Object>` | `rightTree`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BinaryTreeTests()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addLeft_emptyTree_incrementsSize()` Comprueba que el método addLeft incrementa el tamaño del árbol.
    `void` | `addLeft_nodeWithLeftChild_throwsIOE()` Comprueba que el método addLeft lanza InvalidOperationException sobre un nodo que ya tiene hijo izquierdo.
    `void` | `addLeft_normalBehavior_newNodeExistent()` Comprueba que luego del método addLeft el nuevo nodo fue agregado al árbol.
    `void` | `addLeft_normalBehavior_returnsNewNode()` Comprueba que el método addLeft retorna correctamente el hijo añadido.
    `void` | `addLeft_nullPosition_throwsIPE()` Comprueba que el método addLeft lanza InvalidPositionException con una posición nula.
    `void` | `addRight_emptyTree_incrementsSize()` Comprueba que el método addRight incrementa el tamaño del árbol.
    `void` | `addRight_nodeWithRightChild_throwsIOE()` Comprueba que el método addRight lanza InvalidOperationException sobre un nodo que ya tiene hijo derecho.
    `void` | `addRight_normalBehavior_newNodeExistent()` Comprueba que luego del método addRight el nuevo nodo fue agregado al árbol.
    `void` | `addRight_normalBehavior_returnsNewNode()` Comprueba que el método addRight retorna correctamente el hijo añadido.
    `void` | `addRight_nullPosition_throwsIPE()` Comprueba que el método addRight lanza InvalidPositionException con una posición nula.
    `void` | `Attach_internalNode_throwsIPE()` Comprueba que el método attach lanza InvalidPositionException si es invocado sobre un nodo interno.
    `void` | `Attach_normalBehavior_nodesAttached()` Comprueba que luego de un attach el árbol tiene la nueva estructura.
    `void` | `Attach_normalBehavior_sizeIncremented()` Comprueba que luego de un attach el tamaño del árbol se incrementa acorde a los subárboles añadidos.
    `void` | `attach_nullPosition_throwsIPE()` Comprueba que el método attach lanza InvalidPositionException con una posición nula.
    `void` | `children_nullPosition_throwsIPE()` Comprueba que el método children lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `children_onlyLeftChild_returnsCollectionWithLeftChild()` Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo izquierdo.
    `void` | `children_onlyRightChild_returnsCollectionWithRightChild()` Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo derecho.
    `void` | `children_twoChildren_returnsCollectionWithChildren()` Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo izquierdo.
    `void` | `children_WithoutChildren_returnsEmptyCollection()` Comprueba que el método children retorna una colección vacía para un nodo sin hijos.
    `void` | `createRoot_emptyTree_createsRoot()` Comprueba que el método createRoot retorna correctamente la posición con el elemento pasado por parámetro.
    `void` | `createRoot_emptyTree_treeSizeEqualsOne()` Comprueba que el tamaño del árbol es 1 luego de invocar a createRoot.
    `void` | `createRoot_existingRoot_throwsIOE()` Comprueba que el método createRoot lanza la excepción InvalidOperationException cuando se invoca sobre un árbol que ya tiene raíz.
    `void` | `hasLeft_leftAndRightChildren_returnsTrue()` Comprueba que el método hasLeft retorna true con un nodo que tiene hijo izquierdo y derecho.
    `void` | `hasLeft_nullPosition_throwsIPE()` Comprueba que el método hasLeft lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `hasLeft_onlyLeftChild_returnsTrue()` Comprueba que el método hasLeft retorna true con un nodo que solo tiene hijo izquierdo.
    `void` | `hasLeft_onlyRightChild_returnsFalse()` Comprueba que el método hasLeft retorna false con un nodo que no tiene hijo izquierdo pero tiene hijo derecho.
    `void` | `hasLeft_withoutChildren_returnsFalse()` Comprueba que el método hasLeft retorna false con un nodo que no tiene hijos.
    `void` | `hasRight_leftAndRightChildren_returnsTrue()` Comprueba que el método hasRight retorna true con un nodo que tiene hijo izquierdo y derecho.
    `void` | `hasRight_nullPosition_throwsIPE()` Comprueba que el método hasRight lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `hasRight_onlyLeftChild_returnsFalse()` Comprueba que el método hasRight retorna false con un nodo que no tiene hijo derecho pero tiene hijo izquierdo.
    `void` | `hasRight_onlyRightChild_returnsTrue()` Comprueba que el método hasRight retorna true con un nodo que solo tiene hijo derecho.
    `void` | `hasRight_withoutChildren_returnsFalse()` Comprueba que el método hasRight retorna false con un nodo que no tiene hijos.
    `void` | `isEmpty_emptyTree_returnsTrue()` Comprueba que el método isEmpty responda correctamente con un árbol vacío.
    `void` | `isEmpty_notEmptyTree_returnsFalse()` Comprueba que el método isEmpty responda correctamente con un árbol no vacío.
    `void` | `isExternal_nullPosition_throwsIPE()` Comprueba que el método isExternal lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `isExternal_onExternalNode_returnsTrue()` Comprueba que el método isExternal retorna true en caso de recibir un nodo externo.
    `void` | `isExternal_onInternalNode_returnsFalse()` Comprueba que el método isExternal retorna false en caso de recibir un nodo interno.
    `void` | `isInternal_nullPosition_throwsIPE()` Comprueba que el método isInternal lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `isInternal_onExternalNode_returnsFalse()` Comprueba que el método isInternal retorna false en caso de recibir un nodo externo.
    `void` | `isInternal_onInternalNode_returnsTrue()` Comprueba que el método isInternal retorna true en caso de recibir un nodo interno.
    `void` | `isRoot_notOnRoot_returnsFalse()` Comprueba que el método isRoot retorna false al ser llamado con un nodo distinto a la raíz del árbol.
    `void` | `isRoot_nullPosition_throwsIPE()` Comprueba que el método isRoot lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `isRoot_onRoot_returnsTrue()` Comprueba que el método isRoot retorna true al ser llamado con la raíz del árbol.
    `void` | `iterator_emptyTree_returnsEmptyIterator()` Comprueba que el método iterator retorna un iterador vacío para un árbol vacío.
    `void` | `iterator_onlyRoot_iteratorSizeEqualsOne()` Comprueba que el método iterator retorna un iterador con un solo elemento para un árbol con solo la raíz.
    `void` | `left_nullPosition_throwsIPE()` Comprueba que el método left lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `left_positionWithOnlyLeftChild_returnsLeftChild()` Comprueba que el método left retorna correctamente la posición del hijo izquierdo de un nodo que solo tiene hijo izquierdo.
    `void` | `left_positionWithoutChildren_throwsBVE()` Comprueba que el método left lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo izquierdo ni derecho.
    `void` | `left_positionWithoutLeftChild_throwsBVE()` Comprueba que el método left lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo izquierdo pero tiene hijo derecho.
    `void` | `left_positionWithTwoChilds_returnsLeftChild()` Comprueba que el método left retorna correctamente la posición del hijo izquierdo de un nodo que tiene hijo izquierdo y derecho.
    `void` | `parent_nullPosition_throwsIPE()` Comprueba que el método parent lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `parent_onRoot_throwsBVE()` Comprueba que el método parent lanza la excepción BoundaryViolationException al recibir la raíz del árbol.
    `void` | `parent_validPosition_returnsParent()` Comprueba que el método parent retorna correctamente el padre de un nodo dado
    `void` | `positions_emptyTree_returnsEmptyIterable()` Comprueba que el método positions retorna una colección iterable vacía para un árbol vacío.
    `void` | `positions_onlyRoot_iterableSizeEqualsOne()` Comprueba que el método positions retorna una colección iterable con un solo elemento para un árbol con solo la raíz.
    `void` | `remove_internalNode_replacedInParentChildrenList()` Comprueba que luego de invocar al método remove sobre un nodo interno, el nodo eliminado es reemplazado por su hijo en la lista de hijos del padre.
    `void` | `remove_leafNode_removedFromParentChildrenList()` Comprueba que luego de invocar al método remove sobre un nodo hoja, el nodo eliminado ya no aparece en la lista de hijos del padre.
    `void` | `remove_nullPosition_throwsIPE()` Comprueba que el método remove lanza InvalidPositionException con una posición nula.
    `void` | `remove_twoChildren_throwsIOE()` Comprueba que el método remove lanza InvalidOperationException sobre un nodo con dos hijos.
    `void` | `remove_validPosition_removedNode()` Comprueba que luego de invocar al método remove el nodo a eliminar ya no aparece en el listado de nodos del árbol.
    `void` | `remove_validPosition_returnsRemovedElement()` Comprueba que el método remove retorna correctamente el elemento eliminado.
    `void` | `replace_nullPosition_throwsIPE()` Comprueba que el método replace lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `replace_validPosition_returnsOldElement()` Comprueba que el método replace retorna correctamente el elemento previo en la posición pasada por parámetro.
    `void` | `replace_validPosition_setsNewElement()` Comprueba que el método replace setea correctamente el nuevo elemento a la posición pasada por parámetro.
    `void` | `right_nullPosition_throwsIPE()` Comprueba que el método right lanza la excepción InvalidPositionException al recibir una posición nula.
    `void` | `right_positionWithOnlyRightChild_returnsRightChild()` Comprueba que el método right retorna correctamente la posición del hijo derecho de un nodo que solo tiene hijo derecho.
    `void` | `right_positionWithoutChildren_throwsBVE()` Comprueba que el método right lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo derecho ni izquierdo.
    `void` | `right_positionWithoutRightChild_throwsBVE()` Comprueba que el método right lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo derecho pero tiene hijo izquierdo.
    `void` | `right_positionWithTwoChilds_returnsRightChild()` Comprueba que el método right retorna correctamente la posición del hijo derecho de un nodo que tiene hijo izquierdo y derecho.
    `void` | `root_emptyTree_throwsETE()` Comprueba que el método root lanza la excepción EmptyTreeException sobre un árbol vacío.
    `void` | `root_notEmptyTree_returnsRoot()` Comprueba que el método root retorna correctamente la posición de la raíz del árbol.
    `void` | `setUp()` Setup inicial de los objetos utilizados en los casos de prueba.
    `void` | `size_emptyTree_returnsZero()` Comprueba que el método size inicialmente retorne 0 con un árbol vacío.
    `void` | `tearDown()` Limpieza de los objetos utilizados en los casos de prueba.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### binaryTree

          BinaryTree<java.lang.Object> binaryTree

    - #### leftTree

          BinaryTree<java.lang.Object> leftTree

    - #### rightTree

          BinaryTree<java.lang.Object> rightTree

    - #### o1

          java.lang.Object o1

    - #### o2

          java.lang.Object o2

  - ### Constructor Detail

    - #### BinaryTreeTests

          public BinaryTreeTests()

  - ### Method Detail

    - #### setUp

          public void setUp()

      Setup inicial de los objetos utilizados en los casos de prueba. (llamado antes de cada test)

    - #### tearDown

          public void tearDown()

      Limpieza de los objetos utilizados en los casos de prueba. (llamado después de cada test)

    - #### size_emptyTree_returnsZero

          public void size_emptyTree_returnsZero()

      Comprueba que el método size inicialmente retorne 0 con un árbol vacío.

    - #### isEmpty_emptyTree_returnsTrue

          public void isEmpty_emptyTree_returnsTrue()

      Comprueba que el método isEmpty responda correctamente con un árbol vacío.

    - #### isEmpty_notEmptyTree_returnsFalse

          public void isEmpty_notEmptyTree_returnsFalse()
                                                 throws InvalidOperationException

      Comprueba que el método isEmpty responda correctamente con un árbol no vacío.
      Throws:
        `InvalidOperationException`

    - #### iterator_emptyTree_returnsEmptyIterator

          public void iterator_emptyTree_returnsEmptyIterator()

      Comprueba que el método iterator retorna un iterador vacío para un árbol vacío.

    - #### iterator_onlyRoot_iteratorSizeEqualsOne

          public void iterator_onlyRoot_iteratorSizeEqualsOne()
                                                       throws InvalidOperationException

      Comprueba que el método iterator retorna un iterador con un solo elemento para un árbol con solo la raíz.
      Throws:
        `InvalidOperationException`

    - #### positions_emptyTree_returnsEmptyIterable

          public void positions_emptyTree_returnsEmptyIterable()

      Comprueba que el método positions retorna una colección iterable vacía para un árbol vacío.

    - #### positions_onlyRoot_iterableSizeEqualsOne

          public void positions_onlyRoot_iterableSizeEqualsOne()
                                                        throws InvalidOperationException

      Comprueba que el método positions retorna una colección iterable con un solo elemento para un árbol con solo la raíz.
      Throws:
        `InvalidOperationException`

    - #### replace_nullPosition_throwsIPE

          public void replace_nullPosition_throwsIPE()
                                              throws InvalidOperationException,
                                                     TDALista.InvalidPositionException

      Comprueba que el método replace lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### replace_validPosition_returnsOldElement

          public void replace_validPosition_returnsOldElement()
                                                       throws InvalidOperationException,
                                                              EmptyTreeException,
                                                              TDALista.InvalidPositionException

      Comprueba que el método replace retorna correctamente el elemento previo en la posición pasada por parámetro.
      Throws:
        `InvalidOperationException`
        `EmptyTreeException`
        `TDALista.InvalidPositionException`

    - #### replace_validPosition_setsNewElement

          public void replace_validPosition_setsNewElement()
                                                    throws InvalidOperationException,
                                                           EmptyTreeException,
                                                           TDALista.InvalidPositionException

      Comprueba que el método replace setea correctamente el nuevo elemento a la posición pasada por parámetro.
      Throws:
        `InvalidOperationException`
        `EmptyTreeException`
        `TDALista.InvalidPositionException`

    - #### root_emptyTree_throwsETE

          public void root_emptyTree_throwsETE()
                                        throws EmptyTreeException

      Comprueba que el método root lanza la excepción EmptyTreeException sobre un árbol vacío.
      Throws:
        `EmptyTreeException`

    - #### root_notEmptyTree_returnsRoot

          public void root_notEmptyTree_returnsRoot()
                                             throws InvalidOperationException,
                                                    EmptyTreeException,
                                                    TDALista.InvalidPositionException

      Comprueba que el método root retorna correctamente la posición de la raíz del árbol.
      Throws:
        `InvalidOperationException`
        `EmptyTreeException`
        `TDALista.InvalidPositionException`

    - #### parent_nullPosition_throwsIPE

          public void parent_nullPosition_throwsIPE()
                                             throws TDALista.InvalidPositionException,
                                                    InvalidOperationException,
                                                    TDALista.BoundaryViolationException

      Comprueba que el método parent lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### parent_onRoot_throwsBVE

          public void parent_onRoot_throwsBVE()
                                       throws TDALista.InvalidPositionException,
                                              InvalidOperationException,
                                              TDALista.BoundaryViolationException

      Comprueba que el método parent lanza la excepción BoundaryViolationException al recibir la raíz del árbol.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### parent_validPosition_returnsParent

          public void parent_validPosition_returnsParent()
                                                  throws TDALista.InvalidPositionException,
                                                         InvalidOperationException,
                                                         TDALista.BoundaryViolationException

      Comprueba que el método parent retorna correctamente el padre de un nodo dado
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### children_nullPosition_throwsIPE

          public void children_nullPosition_throwsIPE()
                                               throws TDALista.InvalidPositionException,
                                                      InvalidOperationException

      Comprueba que el método children lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### children_WithoutChildren_returnsEmptyCollection

          public void children_WithoutChildren_returnsEmptyCollection()
                                                               throws InvalidOperationException,
                                                                      TDALista.InvalidPositionException

      Comprueba que el método children retorna una colección vacía para un nodo sin hijos.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### children_onlyLeftChild_returnsCollectionWithLeftChild

          public void children_onlyLeftChild_returnsCollectionWithLeftChild()
                                                                     throws InvalidOperationException,
                                                                            TDALista.InvalidPositionException

      Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo izquierdo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### children_onlyRightChild_returnsCollectionWithRightChild

          public void children_onlyRightChild_returnsCollectionWithRightChild()
                                                                       throws InvalidOperationException,
                                                                              TDALista.InvalidPositionException

      Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo derecho.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### children_twoChildren_returnsCollectionWithChildren

          public void children_twoChildren_returnsCollectionWithChildren()
                                                                  throws InvalidOperationException,
                                                                         TDALista.InvalidPositionException

      Comprueba que el método children retorna correctamente la colección de hijos para un nodo con solo hijo izquierdo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isInternal_nullPosition_throwsIPE

          public void isInternal_nullPosition_throwsIPE()
                                                 throws TDALista.InvalidPositionException,
                                                        InvalidOperationException

      Comprueba que el método isInternal lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### isInternal_onExternalNode_returnsFalse

          public void isInternal_onExternalNode_returnsFalse()
                                                      throws InvalidOperationException,
                                                             TDALista.InvalidPositionException

      Comprueba que el método isInternal retorna false en caso de recibir un nodo externo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isInternal_onInternalNode_returnsTrue

          public void isInternal_onInternalNode_returnsTrue()
                                                     throws InvalidOperationException,
                                                            TDALista.InvalidPositionException

      Comprueba que el método isInternal retorna true en caso de recibir un nodo interno.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isExternal_nullPosition_throwsIPE

          public void isExternal_nullPosition_throwsIPE()
                                                 throws TDALista.InvalidPositionException,
                                                        InvalidOperationException

      Comprueba que el método isExternal lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### isExternal_onInternalNode_returnsFalse

          public void isExternal_onInternalNode_returnsFalse()
                                                      throws InvalidOperationException,
                                                             TDALista.InvalidPositionException

      Comprueba que el método isExternal retorna false en caso de recibir un nodo interno.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isExternal_onExternalNode_returnsTrue

          public void isExternal_onExternalNode_returnsTrue()
                                                     throws InvalidOperationException,
                                                            TDALista.InvalidPositionException

      Comprueba que el método isExternal retorna true en caso de recibir un nodo externo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isRoot_nullPosition_throwsIPE

          public void isRoot_nullPosition_throwsIPE()
                                             throws TDALista.InvalidPositionException,
                                                    InvalidOperationException

      Comprueba que el método isRoot lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### isRoot_onRoot_returnsTrue

          public void isRoot_onRoot_returnsTrue()
                                         throws InvalidOperationException,
                                                TDALista.InvalidPositionException

      Comprueba que el método isRoot retorna true al ser llamado con la raíz del árbol.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### isRoot_notOnRoot_returnsFalse

          public void isRoot_notOnRoot_returnsFalse()
                                             throws InvalidOperationException,
                                                    TDALista.InvalidPositionException

      Comprueba que el método isRoot retorna false al ser llamado con un nodo distinto a la raíz del árbol.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### left_nullPosition_throwsIPE

          public void left_nullPosition_throwsIPE()
                                           throws TDALista.InvalidPositionException,
                                                  InvalidOperationException,
                                                  TDALista.BoundaryViolationException

      Comprueba que el método left lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### left_positionWithoutChildren_throwsBVE

          public void left_positionWithoutChildren_throwsBVE()
                                                      throws TDALista.InvalidPositionException,
                                                             InvalidOperationException,
                                                             TDALista.BoundaryViolationException

      Comprueba que el método left lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo izquierdo ni derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### left_positionWithoutLeftChild_throwsBVE

          public void left_positionWithoutLeftChild_throwsBVE()
                                                       throws TDALista.InvalidPositionException,
                                                              InvalidOperationException,
                                                              TDALista.BoundaryViolationException

      Comprueba que el método left lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo izquierdo pero tiene hijo derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### left_positionWithOnlyLeftChild_returnsLeftChild

          public void left_positionWithOnlyLeftChild_returnsLeftChild()
                                                               throws InvalidOperationException,
                                                                      TDALista.InvalidPositionException,
                                                                      TDALista.BoundaryViolationException

      Comprueba que el método left retorna correctamente la posición del hijo izquierdo de un nodo que solo tiene hijo izquierdo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `TDALista.BoundaryViolationException`

    - #### left_positionWithTwoChilds_returnsLeftChild

          public void left_positionWithTwoChilds_returnsLeftChild()
                                                           throws InvalidOperationException,
                                                                  TDALista.InvalidPositionException,
                                                                  TDALista.BoundaryViolationException

      Comprueba que el método left retorna correctamente la posición del hijo izquierdo de un nodo que tiene hijo izquierdo y derecho.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `TDALista.BoundaryViolationException`

    - #### right_nullPosition_throwsIPE

          public void right_nullPosition_throwsIPE()
                                            throws TDALista.InvalidPositionException,
                                                   InvalidOperationException,
                                                   TDALista.BoundaryViolationException

      Comprueba que el método right lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### right_positionWithoutChildren_throwsBVE

          public void right_positionWithoutChildren_throwsBVE()
                                                       throws TDALista.InvalidPositionException,
                                                              InvalidOperationException,
                                                              TDALista.BoundaryViolationException

      Comprueba que el método right lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo derecho ni izquierdo.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### right_positionWithoutRightChild_throwsBVE

          public void right_positionWithoutRightChild_throwsBVE()
                                                         throws TDALista.InvalidPositionException,
                                                                InvalidOperationException,
                                                                TDALista.BoundaryViolationException

      Comprueba que el método right lanza la excepción BoundaryViolationException al recibir una posición que no tiene hijo derecho pero tiene hijo izquierdo.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`
        `TDALista.BoundaryViolationException`

    - #### right_positionWithOnlyRightChild_returnsRightChild

          public void right_positionWithOnlyRightChild_returnsRightChild()
                                                                  throws InvalidOperationException,
                                                                         TDALista.InvalidPositionException,
                                                                         TDALista.BoundaryViolationException

      Comprueba que el método right retorna correctamente la posición del hijo derecho de un nodo que solo tiene hijo derecho.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `TDALista.BoundaryViolationException`

    - #### right_positionWithTwoChilds_returnsRightChild

          public void right_positionWithTwoChilds_returnsRightChild()
                                                             throws InvalidOperationException,
                                                                    TDALista.InvalidPositionException,
                                                                    TDALista.BoundaryViolationException

      Comprueba que el método right retorna correctamente la posición del hijo derecho de un nodo que tiene hijo izquierdo y derecho.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `TDALista.BoundaryViolationException`

    - #### hasLeft_nullPosition_throwsIPE

          public void hasLeft_nullPosition_throwsIPE()
                                              throws TDALista.InvalidPositionException,
                                                     InvalidOperationException

      Comprueba que el método hasLeft lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasLeft_onlyLeftChild_returnsTrue

          public void hasLeft_onlyLeftChild_returnsTrue()
                                                 throws TDALista.InvalidPositionException,
                                                        InvalidOperationException

      Comprueba que el método hasLeft retorna true con un nodo que solo tiene hijo izquierdo.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasLeft_leftAndRightChildren_returnsTrue

          public void hasLeft_leftAndRightChildren_returnsTrue()
                                                        throws TDALista.InvalidPositionException,
                                                               InvalidOperationException

      Comprueba que el método hasLeft retorna true con un nodo que tiene hijo izquierdo y derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasLeft_onlyRightChild_returnsFalse

          public void hasLeft_onlyRightChild_returnsFalse()
                                                   throws TDALista.InvalidPositionException,
                                                          InvalidOperationException

      Comprueba que el método hasLeft retorna false con un nodo que no tiene hijo izquierdo pero tiene hijo derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasLeft_withoutChildren_returnsFalse

          public void hasLeft_withoutChildren_returnsFalse()
                                                    throws TDALista.InvalidPositionException,
                                                           InvalidOperationException

      Comprueba que el método hasLeft retorna false con un nodo que no tiene hijos.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasRight_nullPosition_throwsIPE

          public void hasRight_nullPosition_throwsIPE()
                                               throws TDALista.InvalidPositionException,
                                                      InvalidOperationException

      Comprueba que el método hasRight lanza la excepción InvalidPositionException al recibir una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasRight_onlyRightChild_returnsTrue

          public void hasRight_onlyRightChild_returnsTrue()
                                                   throws TDALista.InvalidPositionException,
                                                          InvalidOperationException

      Comprueba que el método hasRight retorna true con un nodo que solo tiene hijo derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasRight_leftAndRightChildren_returnsTrue

          public void hasRight_leftAndRightChildren_returnsTrue()
                                                         throws TDALista.InvalidPositionException,
                                                                InvalidOperationException

      Comprueba que el método hasRight retorna true con un nodo que tiene hijo izquierdo y derecho.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasRight_onlyLeftChild_returnsFalse

          public void hasRight_onlyLeftChild_returnsFalse()
                                                   throws TDALista.InvalidPositionException,
                                                          InvalidOperationException

      Comprueba que el método hasRight retorna false con un nodo que no tiene hijo derecho pero tiene hijo izquierdo.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### hasRight_withoutChildren_returnsFalse

          public void hasRight_withoutChildren_returnsFalse()
                                                     throws TDALista.InvalidPositionException,
                                                            InvalidOperationException

      Comprueba que el método hasRight retorna false con un nodo que no tiene hijos.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### createRoot_existingRoot_throwsIOE

          public void createRoot_existingRoot_throwsIOE()
                                                 throws InvalidOperationException

      Comprueba que el método createRoot lanza la excepción InvalidOperationException cuando se invoca sobre un árbol que ya tiene raíz.
      Throws:
        `InvalidOperationException`

    - #### createRoot_emptyTree_createsRoot

          public void createRoot_emptyTree_createsRoot()
                                                throws InvalidOperationException

      Comprueba que el método createRoot retorna correctamente la posición con el elemento pasado por parámetro.
      Throws:
        `InvalidOperationException`

    - #### createRoot_emptyTree_treeSizeEqualsOne

          public void createRoot_emptyTree_treeSizeEqualsOne()
                                                      throws InvalidOperationException

      Comprueba que el tamaño del árbol es 1 luego de invocar a createRoot.
      Throws:
        `InvalidOperationException`

    - #### addLeft_nullPosition_throwsIPE

          public void addLeft_nullPosition_throwsIPE()
                                              throws TDALista.InvalidPositionException,
                                                     InvalidOperationException

      Comprueba que el método addLeft lanza InvalidPositionException con una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addLeft_nodeWithLeftChild_throwsIOE

          public void addLeft_nodeWithLeftChild_throwsIOE()
                                                   throws InvalidOperationException,
                                                          TDALista.InvalidPositionException,
                                                          EmptyTreeException

      Comprueba que el método addLeft lanza InvalidOperationException sobre un nodo que ya tiene hijo izquierdo.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `EmptyTreeException`

    - #### addLeft_normalBehavior_returnsNewNode

          public void addLeft_normalBehavior_returnsNewNode()
                                                     throws EmptyTreeException,
                                                            TDALista.InvalidPositionException,
                                                            InvalidOperationException

      Comprueba que el método addLeft retorna correctamente el hijo añadido.
      Throws:
        `EmptyTreeException`
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addLeft_normalBehavior_newNodeExistent

          public void addLeft_normalBehavior_newNodeExistent()
                                                      throws EmptyTreeException,
                                                             TDALista.InvalidPositionException,
                                                             InvalidOperationException

      Comprueba que luego del método addLeft el nuevo nodo fue agregado al árbol.
      Throws:
        `EmptyTreeException`
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addLeft_emptyTree_incrementsSize

          public void addLeft_emptyTree_incrementsSize()
                                                throws EmptyTreeException,
                                                       InvalidOperationException,
                                                       TDALista.InvalidPositionException

      Comprueba que el método addLeft incrementa el tamaño del árbol.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### addRight_nullPosition_throwsIPE

          public void addRight_nullPosition_throwsIPE()
                                               throws TDALista.InvalidPositionException,
                                                      InvalidOperationException

      Comprueba que el método addRight lanza InvalidPositionException con una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addRight_nodeWithRightChild_throwsIOE

          public void addRight_nodeWithRightChild_throwsIOE()
                                                     throws InvalidOperationException,
                                                            TDALista.InvalidPositionException,
                                                            EmptyTreeException

      Comprueba que el método addRight lanza InvalidOperationException sobre un nodo que ya tiene hijo derecho.
      Throws:
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `EmptyTreeException`

    - #### addRight_normalBehavior_returnsNewNode

          public void addRight_normalBehavior_returnsNewNode()
                                                      throws EmptyTreeException,
                                                             TDALista.InvalidPositionException,
                                                             InvalidOperationException

      Comprueba que el método addRight retorna correctamente el hijo añadido.
      Throws:
        `EmptyTreeException`
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addRight_normalBehavior_newNodeExistent

          public void addRight_normalBehavior_newNodeExistent()
                                                       throws EmptyTreeException,
                                                              TDALista.InvalidPositionException,
                                                              InvalidOperationException

      Comprueba que luego del método addRight el nuevo nodo fue agregado al árbol.
      Throws:
        `EmptyTreeException`
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### addRight_emptyTree_incrementsSize

          public void addRight_emptyTree_incrementsSize()
                                                 throws EmptyTreeException,
                                                        InvalidOperationException,
                                                        TDALista.InvalidPositionException

      Comprueba que el método addRight incrementa el tamaño del árbol.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### remove_nullPosition_throwsIPE

          public void remove_nullPosition_throwsIPE()
                                             throws TDALista.InvalidPositionException,
                                                    InvalidOperationException

      Comprueba que el método remove lanza InvalidPositionException con una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### remove_twoChildren_throwsIOE

          public void remove_twoChildren_throwsIOE()
                                            throws InvalidOperationException,
                                                   EmptyTreeException,
                                                   TDALista.InvalidPositionException

      Comprueba que el método remove lanza InvalidOperationException sobre un nodo con dos hijos.
      Throws:
        `InvalidOperationException`
        `EmptyTreeException`
        `TDALista.InvalidPositionException`

    - #### remove_validPosition_returnsRemovedElement

          public void remove_validPosition_returnsRemovedElement()
                                                          throws EmptyTreeException,
                                                                 InvalidOperationException,
                                                                 TDALista.InvalidPositionException

      Comprueba que el método remove retorna correctamente el elemento eliminado.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### remove_validPosition_removedNode

          public void remove_validPosition_removedNode()
                                                throws EmptyTreeException,
                                                       InvalidOperationException,
                                                       TDALista.InvalidPositionException

      Comprueba que luego de invocar al método remove el nodo a eliminar ya no aparece en el listado de nodos del árbol.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### remove_leafNode_removedFromParentChildrenList

          public void remove_leafNode_removedFromParentChildrenList()
                                                             throws EmptyTreeException,
                                                                    InvalidOperationException,
                                                                    TDALista.InvalidPositionException

      Comprueba que luego de invocar al método remove sobre un nodo hoja, el nodo eliminado ya no aparece en la lista de hijos del padre.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### remove_internalNode_replacedInParentChildrenList

          public void remove_internalNode_replacedInParentChildrenList()
                                                                throws EmptyTreeException,
                                                                       InvalidOperationException,
                                                                       TDALista.InvalidPositionException

      Comprueba que luego de invocar al método remove sobre un nodo interno, el nodo eliminado es reemplazado por su hijo en la lista de hijos del padre.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### attach_nullPosition_throwsIPE

          public void attach_nullPosition_throwsIPE()
                                             throws TDALista.InvalidPositionException,
                                                    InvalidOperationException

      Comprueba que el método attach lanza InvalidPositionException con una posición nula.
      Throws:
        `TDALista.InvalidPositionException`
        `InvalidOperationException`

    - #### Attach_internalNode_throwsIPE

          public void Attach_internalNode_throwsIPE()
                                             throws TDALista.InvalidPositionException,
                                                    EmptyTreeException,
                                                    InvalidOperationException

      Comprueba que el método attach lanza InvalidPositionException si es invocado sobre un nodo interno.
      Throws:
        `TDALista.InvalidPositionException`
        `EmptyTreeException`
        `InvalidOperationException`

    - #### Attach_normalBehavior_sizeIncremented

          public void Attach_normalBehavior_sizeIncremented()
                                                     throws EmptyTreeException,
                                                            InvalidOperationException,
                                                            TDALista.InvalidPositionException

      Comprueba que luego de un attach el tamaño del árbol se incrementa acorde a los subárboles añadidos.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`

    - #### Attach_normalBehavior_nodesAttached

          public void Attach_normalBehavior_nodesAttached()
                                                   throws EmptyTreeException,
                                                          InvalidOperationException,
                                                          TDALista.InvalidPositionException,
                                                          TDALista.BoundaryViolationException

      Comprueba que luego de un attach el árbol tiene la nueva estructura.
      Throws:
        `EmptyTreeException`
        `InvalidOperationException`
        `TDALista.InvalidPositionException`
        `TDALista.BoundaryViolationException`